//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS PrivateNetworks service.
///
/// Amazon Web Services Private 5G is a managed service that makes it easy to deploy, operate, and scale your own private mobile network at your on-premises location. Private 5G provides the pre-configured hardware and software for mobile networks, helps automate setup, and scales capacity on demand to support additional devices as needed.
public struct PrivateNetworks: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the PrivateNetworks client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "PrivateNetworks",
            serviceIdentifier: "private-networks",
            serviceProtocol: .restjson,
            apiVersion: "2021-12-03",
            endpoint: endpoint,
            errorType: PrivateNetworksErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Acknowledges that the specified network order was received.
    @Sendable
    @inlinable
    public func acknowledgeOrderReceipt(_ input: AcknowledgeOrderReceiptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcknowledgeOrderReceiptResponse {
        try await self.client.execute(
            operation: "AcknowledgeOrderReceipt", 
            path: "/v1/orders/acknowledge", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Acknowledges that the specified network order was received.
    ///
    /// Parameters:
    ///   - orderArn: The Amazon Resource Name (ARN) of the order.
    ///   - logger: Logger use during operation
    @inlinable
    public func acknowledgeOrderReceipt(
        orderArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcknowledgeOrderReceiptResponse {
        let input = AcknowledgeOrderReceiptRequest(
            orderArn: orderArn
        )
        return try await self.acknowledgeOrderReceipt(input, logger: logger)
    }

    /// Activates the specified device identifier.
    @Sendable
    @inlinable
    public func activateDeviceIdentifier(_ input: ActivateDeviceIdentifierRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ActivateDeviceIdentifierResponse {
        try await self.client.execute(
            operation: "ActivateDeviceIdentifier", 
            path: "/v1/device-identifiers/activate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Activates the specified device identifier.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - deviceIdentifierArn: The Amazon Resource Name (ARN) of the device identifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func activateDeviceIdentifier(
        clientToken: String? = nil,
        deviceIdentifierArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ActivateDeviceIdentifierResponse {
        let input = ActivateDeviceIdentifierRequest(
            clientToken: clientToken, 
            deviceIdentifierArn: deviceIdentifierArn
        )
        return try await self.activateDeviceIdentifier(input, logger: logger)
    }

    /// Activates the specified network site.
    @Sendable
    @inlinable
    public func activateNetworkSite(_ input: ActivateNetworkSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ActivateNetworkSiteResponse {
        try await self.client.execute(
            operation: "ActivateNetworkSite", 
            path: "/v1/network-sites/activate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Activates the specified network site.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - commitmentConfiguration: Determines the duration and renewal status of the commitment period for all pending radio units. If you include commitmentConfiguration in the ActivateNetworkSiteRequest action, you must specify the following:   The commitment period for the radio unit. You can choose a 60-day, 1-year, or 3-year period.   Whether you want your commitment period to automatically renew for one more year after your current commitment period expires.   For pricing, see Amazon Web Services Private 5G Pricing. If you do not include commitmentConfiguration in the ActivateNetworkSiteRequest action, the commitment period is set to 60-days.
    ///   - networkSiteArn: The Amazon Resource Name (ARN) of the network site.
    ///   - shippingAddress: The shipping address of the network site.
    ///   - logger: Logger use during operation
    @inlinable
    public func activateNetworkSite(
        clientToken: String? = nil,
        commitmentConfiguration: CommitmentConfiguration? = nil,
        networkSiteArn: String,
        shippingAddress: Address,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ActivateNetworkSiteResponse {
        let input = ActivateNetworkSiteRequest(
            clientToken: clientToken, 
            commitmentConfiguration: commitmentConfiguration, 
            networkSiteArn: networkSiteArn, 
            shippingAddress: shippingAddress
        )
        return try await self.activateNetworkSite(input, logger: logger)
    }

    /// Configures the specified network resource.  Use this action to specify the geographic position of the hardware. You must provide Certified Professional Installer (CPI) credentials in the request so that we can obtain spectrum grants. For more information, see Radio units in the Amazon Web Services Private 5G User Guide.
    @Sendable
    @inlinable
    public func configureAccessPoint(_ input: ConfigureAccessPointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ConfigureAccessPointResponse {
        try await self.client.execute(
            operation: "ConfigureAccessPoint", 
            path: "/v1/network-resources/configure", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Configures the specified network resource.  Use this action to specify the geographic position of the hardware. You must provide Certified Professional Installer (CPI) credentials in the request so that we can obtain spectrum grants. For more information, see Radio units in the Amazon Web Services Private 5G User Guide.
    ///
    /// Parameters:
    ///   - accessPointArn: The Amazon Resource Name (ARN) of the network resource.
    ///   - cpiSecretKey: A Base64 encoded string of the CPI certificate associated with the CPI user who is certifying the coordinates of the network resource.
    ///   - cpiUserId: The CPI user ID of the CPI user who is certifying the coordinates of the network resource.
    ///   - cpiUsername: The CPI user name of the CPI user who is certifying the coordinates of the radio unit.
    ///   - cpiUserPassword: The CPI password associated with the CPI certificate in cpiSecretKey.
    ///   - position: The position of the network resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func configureAccessPoint(
        accessPointArn: String,
        cpiSecretKey: String? = nil,
        cpiUserId: String? = nil,
        cpiUsername: String? = nil,
        cpiUserPassword: String? = nil,
        position: Position? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ConfigureAccessPointResponse {
        let input = ConfigureAccessPointRequest(
            accessPointArn: accessPointArn, 
            cpiSecretKey: cpiSecretKey, 
            cpiUserId: cpiUserId, 
            cpiUsername: cpiUsername, 
            cpiUserPassword: cpiUserPassword, 
            position: position
        )
        return try await self.configureAccessPoint(input, logger: logger)
    }

    /// Creates a network.
    @Sendable
    @inlinable
    public func createNetwork(_ input: CreateNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNetworkResponse {
        try await self.client.execute(
            operation: "CreateNetwork", 
            path: "/v1/networks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a network.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - description: The description of the network.
    ///   - networkName: The name of the network. You can't change the name after you create the network.
    ///   - tags:  The tags to apply to the network.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNetwork(
        clientToken: String? = nil,
        description: String? = nil,
        networkName: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNetworkResponse {
        let input = CreateNetworkRequest(
            clientToken: clientToken, 
            description: description, 
            networkName: networkName, 
            tags: tags
        )
        return try await self.createNetwork(input, logger: logger)
    }

    /// Creates a network site.
    @Sendable
    @inlinable
    public func createNetworkSite(_ input: CreateNetworkSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNetworkSiteResponse {
        try await self.client.execute(
            operation: "CreateNetworkSite", 
            path: "/v1/network-sites", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a network site.
    ///
    /// Parameters:
    ///   - availabilityZone: The Availability Zone that is the parent of this site. You can't change the Availability Zone after you create the site.
    ///   - availabilityZoneId: The ID of the Availability Zone that is the parent of this site. You can't change the Availability Zone after you create the site.
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - description: The description of the site.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - networkSiteName: The name of the site. You can't change the name after you create the site.
    ///   - pendingPlan: Information about the pending plan for this site.
    ///   - tags:  The tags to apply to the network site.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNetworkSite(
        availabilityZone: String? = nil,
        availabilityZoneId: String? = nil,
        clientToken: String? = nil,
        description: String? = nil,
        networkArn: String,
        networkSiteName: String,
        pendingPlan: SitePlan? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNetworkSiteResponse {
        let input = CreateNetworkSiteRequest(
            availabilityZone: availabilityZone, 
            availabilityZoneId: availabilityZoneId, 
            clientToken: clientToken, 
            description: description, 
            networkArn: networkArn, 
            networkSiteName: networkSiteName, 
            pendingPlan: pendingPlan, 
            tags: tags
        )
        return try await self.createNetworkSite(input, logger: logger)
    }

    /// Deactivates the specified device identifier.
    @Sendable
    @inlinable
    public func deactivateDeviceIdentifier(_ input: DeactivateDeviceIdentifierRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeactivateDeviceIdentifierResponse {
        try await self.client.execute(
            operation: "DeactivateDeviceIdentifier", 
            path: "/v1/device-identifiers/deactivate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deactivates the specified device identifier.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - deviceIdentifierArn: The Amazon Resource Name (ARN) of the device identifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func deactivateDeviceIdentifier(
        clientToken: String? = nil,
        deviceIdentifierArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeactivateDeviceIdentifierResponse {
        let input = DeactivateDeviceIdentifierRequest(
            clientToken: clientToken, 
            deviceIdentifierArn: deviceIdentifierArn
        )
        return try await self.deactivateDeviceIdentifier(input, logger: logger)
    }

    /// Deletes the specified network. You must delete network sites before you delete the network. For more information, see DeleteNetworkSite in the API Reference for Amazon Web Services Private 5G.
    @Sendable
    @inlinable
    public func deleteNetwork(_ input: DeleteNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNetworkResponse {
        try await self.client.execute(
            operation: "DeleteNetwork", 
            path: "/v1/networks/{networkArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified network. You must delete network sites before you delete the network. For more information, see DeleteNetworkSite in the API Reference for Amazon Web Services Private 5G.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNetwork(
        clientToken: String? = nil,
        networkArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNetworkResponse {
        let input = DeleteNetworkRequest(
            clientToken: clientToken, 
            networkArn: networkArn
        )
        return try await self.deleteNetwork(input, logger: logger)
    }

    /// Deletes the specified network site. Return the hardware after you delete the network site. You are responsible for minimum charges. For more information, see Hardware returns in the Amazon Web Services Private 5G User Guide.
    @Sendable
    @inlinable
    public func deleteNetworkSite(_ input: DeleteNetworkSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNetworkSiteResponse {
        try await self.client.execute(
            operation: "DeleteNetworkSite", 
            path: "/v1/network-sites/{networkSiteArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified network site. Return the hardware after you delete the network site. You are responsible for minimum charges. For more information, see Hardware returns in the Amazon Web Services Private 5G User Guide.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - networkSiteArn: The Amazon Resource Name (ARN) of the network site.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNetworkSite(
        clientToken: String? = nil,
        networkSiteArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNetworkSiteResponse {
        let input = DeleteNetworkSiteRequest(
            clientToken: clientToken, 
            networkSiteArn: networkSiteArn
        )
        return try await self.deleteNetworkSite(input, logger: logger)
    }

    /// Gets the specified device identifier.
    @Sendable
    @inlinable
    public func getDeviceIdentifier(_ input: GetDeviceIdentifierRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDeviceIdentifierResponse {
        try await self.client.execute(
            operation: "GetDeviceIdentifier", 
            path: "/v1/device-identifiers/{deviceIdentifierArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the specified device identifier.
    ///
    /// Parameters:
    ///   - deviceIdentifierArn: The Amazon Resource Name (ARN) of the device identifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDeviceIdentifier(
        deviceIdentifierArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceIdentifierResponse {
        let input = GetDeviceIdentifierRequest(
            deviceIdentifierArn: deviceIdentifierArn
        )
        return try await self.getDeviceIdentifier(input, logger: logger)
    }

    /// Gets the specified network.
    @Sendable
    @inlinable
    public func getNetwork(_ input: GetNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkResponse {
        try await self.client.execute(
            operation: "GetNetwork", 
            path: "/v1/networks/{networkArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the specified network.
    ///
    /// Parameters:
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetwork(
        networkArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkResponse {
        let input = GetNetworkRequest(
            networkArn: networkArn
        )
        return try await self.getNetwork(input, logger: logger)
    }

    /// Gets the specified network resource.
    @Sendable
    @inlinable
    public func getNetworkResource(_ input: GetNetworkResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkResourceResponse {
        try await self.client.execute(
            operation: "GetNetworkResource", 
            path: "/v1/network-resources/{networkResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the specified network resource.
    ///
    /// Parameters:
    ///   - networkResourceArn: The Amazon Resource Name (ARN) of the network resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkResource(
        networkResourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkResourceResponse {
        let input = GetNetworkResourceRequest(
            networkResourceArn: networkResourceArn
        )
        return try await self.getNetworkResource(input, logger: logger)
    }

    /// Gets the specified network site.
    @Sendable
    @inlinable
    public func getNetworkSite(_ input: GetNetworkSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkSiteResponse {
        try await self.client.execute(
            operation: "GetNetworkSite", 
            path: "/v1/network-sites/{networkSiteArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the specified network site.
    ///
    /// Parameters:
    ///   - networkSiteArn: The Amazon Resource Name (ARN) of the network site.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkSite(
        networkSiteArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkSiteResponse {
        let input = GetNetworkSiteRequest(
            networkSiteArn: networkSiteArn
        )
        return try await self.getNetworkSite(input, logger: logger)
    }

    /// Gets the specified order.
    @Sendable
    @inlinable
    public func getOrder(_ input: GetOrderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOrderResponse {
        try await self.client.execute(
            operation: "GetOrder", 
            path: "/v1/orders/{orderArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the specified order.
    ///
    /// Parameters:
    ///   - orderArn: The Amazon Resource Name (ARN) of the order.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOrder(
        orderArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOrderResponse {
        let input = GetOrderRequest(
            orderArn: orderArn
        )
        return try await self.getOrder(input, logger: logger)
    }

    /// Lists device identifiers. Add filters to your request to return a more specific list of results. Use filters to match the Amazon Resource Name (ARN) of an order, the status of device identifiers, or the ARN of the traffic group. If you specify multiple filters, filters are joined with an OR, and the request
    /// returns results that match all of the specified filters.
    @Sendable
    @inlinable
    public func listDeviceIdentifiers(_ input: ListDeviceIdentifiersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDeviceIdentifiersResponse {
        try await self.client.execute(
            operation: "ListDeviceIdentifiers", 
            path: "/v1/device-identifiers/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists device identifiers. Add filters to your request to return a more specific list of results. Use filters to match the Amazon Resource Name (ARN) of an order, the status of device identifiers, or the ARN of the traffic group. If you specify multiple filters, filters are joined with an OR, and the request
    /// returns results that match all of the specified filters.
    ///
    /// Parameters:
    ///   - filters: The filters.    ORDER - The Amazon Resource Name (ARN) of the order.    STATUS - The status (ACTIVE | INACTIVE).    TRAFFIC_GROUP - The Amazon Resource Name (ARN) of the traffic group.   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - startToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDeviceIdentifiers(
        filters: [DeviceIdentifierFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        startToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDeviceIdentifiersResponse {
        let input = ListDeviceIdentifiersRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn, 
            startToken: startToken
        )
        return try await self.listDeviceIdentifiers(input, logger: logger)
    }

    /// Lists network resources. Add filters to your request to return a more specific list of results. Use filters to match the Amazon Resource Name (ARN) of an order or the status of network resources. If you specify multiple filters, filters are joined with an OR, and the request
    /// returns results that match all of the specified filters.
    @Sendable
    @inlinable
    public func listNetworkResources(_ input: ListNetworkResourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNetworkResourcesResponse {
        try await self.client.execute(
            operation: "ListNetworkResources", 
            path: "/v1/network-resources", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists network resources. Add filters to your request to return a more specific list of results. Use filters to match the Amazon Resource Name (ARN) of an order or the status of network resources. If you specify multiple filters, filters are joined with an OR, and the request
    /// returns results that match all of the specified filters.
    ///
    /// Parameters:
    ///   - filters: The filters.    ORDER - The Amazon Resource Name (ARN) of the order.    STATUS - The status (AVAILABLE | DELETED | DELETING | PENDING | PENDING_RETURN | PROVISIONING | SHIPPED).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - startToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNetworkResources(
        filters: [NetworkResourceFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        startToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNetworkResourcesResponse {
        let input = ListNetworkResourcesRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn, 
            startToken: startToken
        )
        return try await self.listNetworkResources(input, logger: logger)
    }

    /// Lists network sites. Add filters to your request to return a more specific list of results. Use filters to match the status of the network site.
    @Sendable
    @inlinable
    public func listNetworkSites(_ input: ListNetworkSitesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNetworkSitesResponse {
        try await self.client.execute(
            operation: "ListNetworkSites", 
            path: "/v1/network-sites/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists network sites. Add filters to your request to return a more specific list of results. Use filters to match the status of the network site.
    ///
    /// Parameters:
    ///   - filters: The filters. Add filters to your request to return a more specific list of results. Use filters to match the status of the network sites.    STATUS - The status (AVAILABLE | CREATED | DELETED | DEPROVISIONING | PROVISIONING).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - startToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNetworkSites(
        filters: [NetworkSiteFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        startToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNetworkSitesResponse {
        let input = ListNetworkSitesRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn, 
            startToken: startToken
        )
        return try await self.listNetworkSites(input, logger: logger)
    }

    /// Lists networks. Add filters to your request to return a more specific list of results. Use filters to match the status of the network.
    @Sendable
    @inlinable
    public func listNetworks(_ input: ListNetworksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNetworksResponse {
        try await self.client.execute(
            operation: "ListNetworks", 
            path: "/v1/networks/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists networks. Add filters to your request to return a more specific list of results. Use filters to match the status of the network.
    ///
    /// Parameters:
    ///   - filters: The filters.    STATUS - The status (AVAILABLE | CREATED | DELETED | DEPROVISIONING | PROVISIONING).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - startToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNetworks(
        filters: [NetworkFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        startToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNetworksResponse {
        let input = ListNetworksRequest(
            filters: filters, 
            maxResults: maxResults, 
            startToken: startToken
        )
        return try await self.listNetworks(input, logger: logger)
    }

    /// Lists orders. Add filters to your request to return a more specific list of results. Use filters to match the Amazon Resource Name (ARN) of the network site or the status of the order. If you specify multiple filters, filters are joined with an OR, and the request
    /// returns results that match all of the specified filters.
    @Sendable
    @inlinable
    public func listOrders(_ input: ListOrdersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOrdersResponse {
        try await self.client.execute(
            operation: "ListOrders", 
            path: "/v1/orders/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists orders. Add filters to your request to return a more specific list of results. Use filters to match the Amazon Resource Name (ARN) of the network site or the status of the order. If you specify multiple filters, filters are joined with an OR, and the request
    /// returns results that match all of the specified filters.
    ///
    /// Parameters:
    ///   - filters: The filters.    NETWORK_SITE - The Amazon Resource Name (ARN) of the network site.    STATUS - The status (ACKNOWLEDGING | ACKNOWLEDGED | UNACKNOWLEDGED).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - startToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOrders(
        filters: [OrderFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        startToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOrdersResponse {
        let input = ListOrdersRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn, 
            startToken: startToken
        )
        return try await self.listOrders(input, logger: logger)
    }

    /// Lists the tags for the specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Checks the health of the service.
    @Sendable
    @inlinable
    public func ping(logger: Logger = AWSClient.loggingDisabled) async throws -> PingResponse {
        try await self.client.execute(
            operation: "Ping", 
            path: "/ping", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            logger: logger
        )
    }

    /// Use this action to do the following tasks:   Update the duration and renewal status of the commitment period for a radio unit. The update goes into effect immediately.   Request a replacement for a network resource.   Request that you return a network resource.   After you submit a request to replace or return a network resource, the status of the network resource changes to CREATING_SHIPPING_LABEL. The shipping label is available when the status of the network resource is PENDING_RETURN. After the network resource is successfully returned, its status changes to DELETED. For more information, see Return a radio unit.
    @Sendable
    @inlinable
    public func startNetworkResourceUpdate(_ input: StartNetworkResourceUpdateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartNetworkResourceUpdateResponse {
        try await self.client.execute(
            operation: "StartNetworkResourceUpdate", 
            path: "/v1/network-resources/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Use this action to do the following tasks:   Update the duration and renewal status of the commitment period for a radio unit. The update goes into effect immediately.   Request a replacement for a network resource.   Request that you return a network resource.   After you submit a request to replace or return a network resource, the status of the network resource changes to CREATING_SHIPPING_LABEL. The shipping label is available when the status of the network resource is PENDING_RETURN. After the network resource is successfully returned, its status changes to DELETED. For more information, see Return a radio unit.
    ///
    /// Parameters:
    ///   - commitmentConfiguration: Use this action to extend and automatically renew the commitment period for the radio unit. You can do the following:   Change a 60-day commitment to a 1-year or 3-year commitment. The change is immediate and the hourly rate decreases to the rate for the new commitment period.   Change a 1-year commitment to a 3-year commitment. The change is immediate and the hourly rate decreases to the rate for the 3-year commitment period.   Set a 1-year commitment to automatically renew for an additional 1 year. The hourly rate for the additional year will continue to be the same as your existing 1-year rate.   Set a 3-year commitment to automatically renew for an additional 1 year. The hourly rate for the additional year will continue to be the same as your existing 3-year rate.   Turn off a previously-enabled automatic renewal on a 1-year or 3-year commitment. You cannot use the automatic-renewal option for a 60-day commitment.   For pricing, see Amazon Web Services Private 5G Pricing.
    ///   - networkResourceArn: The Amazon Resource Name (ARN) of the network resource.
    ///   - returnReason: The reason for the return. Providing a reason for a return is optional.
    ///   - shippingAddress: The shipping address. If you don't provide a shipping address when replacing or returning a network resource, we use the address from the original order for the network resource.
    ///   - updateType: The update type.    REPLACE - Submits a request to replace a defective radio unit. We provide a shipping label that you can use for the return process and we ship a replacement radio unit to you.    RETURN - Submits a request to return a radio unit that you no longer need. We provide a shipping label that you can use for the return process.    COMMITMENT - Submits a request to change or renew the commitment period. If you choose this value, then you must set  commitmentConfiguration .
    ///   - logger: Logger use during operation
    @inlinable
    public func startNetworkResourceUpdate(
        commitmentConfiguration: CommitmentConfiguration? = nil,
        networkResourceArn: String,
        returnReason: String? = nil,
        shippingAddress: Address? = nil,
        updateType: UpdateType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartNetworkResourceUpdateResponse {
        let input = StartNetworkResourceUpdateRequest(
            commitmentConfiguration: commitmentConfiguration, 
            networkResourceArn: networkResourceArn, 
            returnReason: returnReason, 
            shippingAddress: shippingAddress, 
            updateType: updateType
        )
        return try await self.startNetworkResourceUpdate(input, logger: logger)
    }

    ///  Adds tags to the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Adds tags to the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) of the resource.
    ///   - tags: The tags to add to the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes tags from the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes tags from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: The tag keys.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the specified network site.
    @Sendable
    @inlinable
    public func updateNetworkSite(_ input: UpdateNetworkSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNetworkSiteResponse {
        try await self.client.execute(
            operation: "UpdateNetworkSite", 
            path: "/v1/network-sites/site", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified network site.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - description: The description.
    ///   - networkSiteArn: The Amazon Resource Name (ARN) of the network site.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNetworkSite(
        clientToken: String? = nil,
        description: String? = nil,
        networkSiteArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNetworkSiteResponse {
        let input = UpdateNetworkSiteRequest(
            clientToken: clientToken, 
            description: description, 
            networkSiteArn: networkSiteArn
        )
        return try await self.updateNetworkSite(input, logger: logger)
    }

    /// Updates the specified network site plan.
    @Sendable
    @inlinable
    public func updateNetworkSitePlan(_ input: UpdateNetworkSitePlanRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNetworkSiteResponse {
        try await self.client.execute(
            operation: "UpdateNetworkSitePlan", 
            path: "/v1/network-sites/plan", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified network site plan.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. For more information, see How to ensure idempotency.
    ///   - networkSiteArn: The Amazon Resource Name (ARN) of the network site.
    ///   - pendingPlan: The pending plan.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNetworkSitePlan(
        clientToken: String? = nil,
        networkSiteArn: String,
        pendingPlan: SitePlan,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNetworkSiteResponse {
        let input = UpdateNetworkSitePlanRequest(
            clientToken: clientToken, 
            networkSiteArn: networkSiteArn, 
            pendingPlan: pendingPlan
        )
        return try await self.updateNetworkSitePlan(input, logger: logger)
    }
}

extension PrivateNetworks {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: PrivateNetworks, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension PrivateNetworks {
    /// Return PaginatorSequence for operation ``listDeviceIdentifiers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDeviceIdentifiersPaginator(
        _ input: ListDeviceIdentifiersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDeviceIdentifiersRequest, ListDeviceIdentifiersResponse> {
        return .init(
            input: input,
            command: self.listDeviceIdentifiers,
            inputKey: \ListDeviceIdentifiersRequest.startToken,
            outputKey: \ListDeviceIdentifiersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDeviceIdentifiers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters.    ORDER - The Amazon Resource Name (ARN) of the order.    STATUS - The status (ACTIVE | INACTIVE).    TRAFFIC_GROUP - The Amazon Resource Name (ARN) of the traffic group.   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDeviceIdentifiersPaginator(
        filters: [DeviceIdentifierFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDeviceIdentifiersRequest, ListDeviceIdentifiersResponse> {
        let input = ListDeviceIdentifiersRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn
        )
        return self.listDeviceIdentifiersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNetworkResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkResourcesPaginator(
        _ input: ListNetworkResourcesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNetworkResourcesRequest, ListNetworkResourcesResponse> {
        return .init(
            input: input,
            command: self.listNetworkResources,
            inputKey: \ListNetworkResourcesRequest.startToken,
            outputKey: \ListNetworkResourcesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNetworkResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters.    ORDER - The Amazon Resource Name (ARN) of the order.    STATUS - The status (AVAILABLE | DELETED | DELETING | PENDING | PENDING_RETURN | PROVISIONING | SHIPPED).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkResourcesPaginator(
        filters: [NetworkResourceFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNetworkResourcesRequest, ListNetworkResourcesResponse> {
        let input = ListNetworkResourcesRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn
        )
        return self.listNetworkResourcesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNetworkSites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkSitesPaginator(
        _ input: ListNetworkSitesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNetworkSitesRequest, ListNetworkSitesResponse> {
        return .init(
            input: input,
            command: self.listNetworkSites,
            inputKey: \ListNetworkSitesRequest.startToken,
            outputKey: \ListNetworkSitesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNetworkSites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters. Add filters to your request to return a more specific list of results. Use filters to match the status of the network sites.    STATUS - The status (AVAILABLE | CREATED | DELETED | DEPROVISIONING | PROVISIONING).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkSitesPaginator(
        filters: [NetworkSiteFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNetworkSitesRequest, ListNetworkSitesResponse> {
        let input = ListNetworkSitesRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn
        )
        return self.listNetworkSitesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworksPaginator(
        _ input: ListNetworksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNetworksRequest, ListNetworksResponse> {
        return .init(
            input: input,
            command: self.listNetworks,
            inputKey: \ListNetworksRequest.startToken,
            outputKey: \ListNetworksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters.    STATUS - The status (AVAILABLE | CREATED | DELETED | DEPROVISIONING | PROVISIONING).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworksPaginator(
        filters: [NetworkFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNetworksRequest, ListNetworksResponse> {
        let input = ListNetworksRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.listNetworksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOrders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrdersPaginator(
        _ input: ListOrdersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOrdersRequest, ListOrdersResponse> {
        return .init(
            input: input,
            command: self.listOrders,
            inputKey: \ListOrdersRequest.startToken,
            outputKey: \ListOrdersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOrders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters.    NETWORK_SITE - The Amazon Resource Name (ARN) of the network site.    STATUS - The status (ACKNOWLEDGING | ACKNOWLEDGED | UNACKNOWLEDGED).   Filter values are case sensitive. If you specify multiple  values for a filter, the values are joined with an OR, and the request returns  all results that match any of the specified values.
    ///   - maxResults: The maximum number of results to return.
    ///   - networkArn: The Amazon Resource Name (ARN) of the network.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrdersPaginator(
        filters: [OrderFilterKeys: [String]]? = nil,
        maxResults: Int? = nil,
        networkArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOrdersRequest, ListOrdersResponse> {
        let input = ListOrdersRequest(
            filters: filters, 
            maxResults: maxResults, 
            networkArn: networkArn
        )
        return self.listOrdersPaginator(input, logger: logger)
    }
}

extension PrivateNetworks.ListDeviceIdentifiersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> PrivateNetworks.ListDeviceIdentifiersRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            networkArn: self.networkArn,
            startToken: token
        )
    }
}

extension PrivateNetworks.ListNetworkResourcesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> PrivateNetworks.ListNetworkResourcesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            networkArn: self.networkArn,
            startToken: token
        )
    }
}

extension PrivateNetworks.ListNetworkSitesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> PrivateNetworks.ListNetworkSitesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            networkArn: self.networkArn,
            startToken: token
        )
    }
}

extension PrivateNetworks.ListNetworksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> PrivateNetworks.ListNetworksRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            startToken: token
        )
    }
}

extension PrivateNetworks.ListOrdersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> PrivateNetworks.ListOrdersRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            networkArn: self.networkArn,
            startToken: token
        )
    }
}
